gdk_surface_is_visible
gdk_surface_is_viewable
gdk_surface_get_state
-gdk_surface_iconify
-gdk_surface_deiconify
+gdk_surface_minimize
+gdk_surface_unminimize
gdk_surface_stick
gdk_surface_unstick
gdk_surface_maximize
gtk_window_present
gtk_window_present_with_time
gtk_window_close
-gtk_window_iconify
-gtk_window_deiconify
+gtk_window_minimize
+gtk_window_unminimize
gtk_window_stick
gtk_window_unstick
gtk_window_maximize
<para>
GTK has functions for asking the window manager to do various things;
see for example <link
-linkend="gtk-window-iconify">gtk_window_iconify()</link> or <link
+linkend="gtk-window-minimize">gtk_window_minimize()</link> or <link
linkend="gtk-window-maximize">gtk_window_maximize()</link> or <link
linkend="gtk-window-set-decorated">gtk_window_set_decorated()</link>.
Keep in mind that most window managers <emphasis>will</emphasis> ignore
}
static void
-gdk_broadway_surface_iconify (GdkSurface *surface)
+gdk_broadway_surface_minimize (GdkSurface *surface)
{
if (GDK_SURFACE_DESTROYED (surface) ||
!SURFACE_IS_TOPLEVEL (surface))
}
static void
-gdk_broadway_surface_deiconify (GdkSurface *surface)
+gdk_broadway_surface_unminimize (GdkSurface *surface)
{
if (GDK_SURFACE_DESTROYED (surface) ||
!SURFACE_IS_TOPLEVEL (surface))
impl_class->set_focus_on_map = gdk_broadway_surface_set_focus_on_map;
impl_class->set_icon_list = gdk_broadway_surface_set_icon_list;
impl_class->set_icon_name = gdk_broadway_surface_set_icon_name;
- impl_class->iconify = gdk_broadway_surface_iconify;
- impl_class->deiconify = gdk_broadway_surface_deiconify;
+ impl_class->minimize = gdk_broadway_surface_minimize;
+ impl_class->unminimize = gdk_broadway_surface_unminimize;
impl_class->stick = gdk_broadway_surface_stick;
impl_class->unstick = gdk_broadway_surface_unstick;
impl_class->maximize = gdk_broadway_surface_maximize;
}
/**
- * gdk_surface_iconify:
+ * gdk_surface_minimize:
* @surface: a toplevel #GdkSurface
*
- * Asks to iconify (minimize) @surface. The window manager may choose
- * to ignore the request, but normally will honor it. Using
- * gtk_window_iconify() is preferred, if you have a #GtkWindow widget.
+ * Asks to minimize the @surface.
*
- * This function only makes sense when @surface is a toplevel surface.
+ * The windowing system may choose to ignore the request.
*
- **/
+ * You can track the result of this request by using the #GdkSurface:state
+ * property.
+ *
+ * This function only makes sense when @surface is a toplevel surface.
+ */
void
-gdk_surface_iconify (GdkSurface *surface)
+gdk_surface_minimize (GdkSurface *surface)
{
- GDK_SURFACE_GET_CLASS (surface)->iconify (surface);
+ g_return_if_fail (GDK_IS_SURFACE (surface));
+
+ GDK_SURFACE_GET_CLASS (surface)->minimize (surface);
}
/**
- * gdk_surface_deiconify:
+ * gdk_surface_unminimize:
* @surface: a toplevel #GdkSurface
*
- * Attempt to deiconify (unminimize) @surface. On X11 the window manager may
- * choose to ignore the request to deiconify. When using GTK,
- * use gtk_window_deiconify() instead of the #GdkSurface variant. Or better yet,
- * you probably want to use gtk_window_present_with_time(), which raises the surface, focuses it,
- * unminimizes it, and puts it on the current desktop.
+ * Asks to unminimize the @surface.
*
- **/
+ * The windowing system may choose to ignore the request.
+ *
+ * You can track the result of this request by using the #GdkSurface:state
+ * property.
+ *
+ * This function only makes sense when @surface is a toplevel surface.
+ */
void
-gdk_surface_deiconify (GdkSurface *surface)
+gdk_surface_unminimize (GdkSurface *surface)
{
- GDK_SURFACE_GET_CLASS (surface)->deiconify (surface);
+ g_return_if_fail (GDK_IS_SURFACE (surface));
+
+ GDK_SURFACE_GET_CLASS (surface)->unminimize (surface);
}
/**
/**
* GdkSurfaceState:
* @GDK_SURFACE_STATE_WITHDRAWN: the surface is not shown
- * @GDK_SURFACE_STATE_ICONIFIED: the surface is minimized
+ * @GDK_SURFACE_STATE_MINIMIZED: the surface is minimized
* @GDK_SURFACE_STATE_MAXIMIZED: the surface is maximized
* @GDK_SURFACE_STATE_STICKY: the surface is sticky
* @GDK_SURFACE_STATE_FULLSCREEN: the surface is maximized without decorations
typedef enum
{
GDK_SURFACE_STATE_WITHDRAWN = 1 << 0,
- GDK_SURFACE_STATE_ICONIFIED = 1 << 1,
+ GDK_SURFACE_STATE_MINIMIZED = 1 << 1,
GDK_SURFACE_STATE_MAXIMIZED = 1 << 2,
GDK_SURFACE_STATE_STICKY = 1 << 3,
GDK_SURFACE_STATE_FULLSCREEN = 1 << 4,
GDK_AVAILABLE_IN_ALL
void gdk_surface_beep (GdkSurface *surface);
GDK_AVAILABLE_IN_ALL
-void gdk_surface_iconify (GdkSurface *surface);
+void gdk_surface_minimize (GdkSurface *surface);
GDK_AVAILABLE_IN_ALL
-void gdk_surface_deiconify (GdkSurface *surface);
+void gdk_surface_unminimize (GdkSurface *surface);
GDK_AVAILABLE_IN_ALL
void gdk_surface_stick (GdkSurface *surface);
GDK_AVAILABLE_IN_ALL
GList *pixbufs);
void (* set_icon_name) (GdkSurface *surface,
const gchar *name);
- void (* iconify) (GdkSurface *surface);
- void (* deiconify) (GdkSurface *surface);
+ void (* minimize) (GdkSurface *surface);
+ void (* unminimize) (GdkSurface *surface);
void (* stick) (GdkSurface *surface);
void (* unstick) (GdkSurface *surface);
void (* maximize) (GdkSurface *surface);
{
GdkSurface *window = [[self contentView] gdkSurface];
- gdk_synthesize_surface_state (window, 0,
- GDK_SURFACE_STATE_ICONIFIED);
+ gdk_synthesize_surface_state (window, 0, GDK_SURFACE_STATE_MINIMIZED);
}
-(void)windowDidDeminiaturize:(NSNotification *)aNotification
_gdk_quartz_surface_attach_to_parent (window);
- gdk_synthesize_surface_state (window, GDK_SURFACE_STATE_ICONIFIED, 0);
+ gdk_synthesize_surface_state (window, GDK_SURFACE_STATE_MINIMIZED, 0);
}
-(void)windowDidBecomeKey:(NSNotification *)aNotification
if (window->state & GDK_SURFACE_STATE_MAXIMIZED)
gdk_surface_maximize (window);
- if (window->state & GDK_SURFACE_STATE_ICONIFIED)
- gdk_surface_iconify (window);
+ if (window->state & GDK_SURFACE_STATE_MINIMIZED)
+ gdk_surface_minimize (window);
if (impl->transient_for && !GDK_SURFACE_DESTROYED (impl->transient_for))
_gdk_quartz_surface_attach_to_parent (window);
}
static void
-gdk_quartz_surface_iconify (GdkSurface *window)
+gdk_quartz_surface_minimize (GdkSurface *window)
{
GdkSurfaceImplQuartz *impl;
}
else
{
- gdk_synthesize_surface_state (window,
- 0,
- GDK_SURFACE_STATE_ICONIFIED);
+ gdk_synthesize_surface_state (window, 0, GDK_SURFACE_STATE_MINIMIZED);
}
}
static void
-gdk_quartz_surface_deiconify (GdkSurface *window)
+gdk_quartz_surface_unminimize (GdkSurface *window)
{
GdkSurfaceImplQuartz *impl;
}
else
{
- gdk_synthesize_surface_state (window,
- GDK_SURFACE_STATE_ICONIFIED,
- 0);
+ gdk_synthesize_surface_state (window, GDK_SURFACE_STATE_MINIMIZED, 0);
}
}
impl_class->set_focus_on_map = gdk_quartz_surface_set_focus_on_map;
impl_class->set_icon_list = gdk_quartz_surface_set_icon_list;
impl_class->set_icon_name = gdk_quartz_surface_set_icon_name;
- impl_class->iconify = gdk_quartz_surface_iconify;
- impl_class->deiconify = gdk_quartz_surface_deiconify;
+ impl_class->minimize = gdk_quartz_surface_minimize;
+ impl_class->unminimize = gdk_quartz_surface_unminimize;
impl_class->stick = gdk_quartz_surface_stick;
impl_class->unstick = gdk_quartz_surface_unstick;
impl_class->maximize = gdk_quartz_surface_maximize;
}
static void
-gdk_wayland_surface_iconify (GdkSurface *surface)
+gdk_wayland_surface_minimize (GdkSurface *surface)
{
GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
GdkWaylandDisplay *display_wayland;
}
static void
-gdk_wayland_surface_deiconify (GdkSurface *surface)
+gdk_wayland_surface_unminimize (GdkSurface *surface)
{
if (GDK_SURFACE_DESTROYED (surface) ||
!SURFACE_IS_TOPLEVEL (surface))
return;
if (GDK_SURFACE_IS_MAPPED (surface))
- gdk_surface_show (surface);
+ {
+ gdk_surface_show (surface);
+ }
else
- /* Flip our client side flag, the real work happens on map. */
- gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_ICONIFIED, 0);
+ {
+ /* Flip our client side flag, the real work happens on map. */
+ gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_MINIMIZED, 0);
+ }
}
static void
impl_class->set_focus_on_map = gdk_wayland_surface_set_focus_on_map;
impl_class->set_icon_list = gdk_wayland_surface_set_icon_list;
impl_class->set_icon_name = gdk_wayland_surface_set_icon_name;
- impl_class->iconify = gdk_wayland_surface_iconify;
- impl_class->deiconify = gdk_wayland_surface_deiconify;
+ impl_class->minimize = gdk_wayland_surface_minimize;
+ impl_class->unminimize = gdk_wayland_surface_unminimize;
impl_class->stick = gdk_wayland_surface_stick;
impl_class->unstick = gdk_wayland_surface_unstick;
impl_class->maximize = gdk_wayland_surface_maximize;
{
if (!hide_window)
{
- if (gdk_surface_get_state (window) & GDK_SURFACE_STATE_ICONIFIED)
+ if (gdk_surface_get_state (window) & GDK_SURFACE_STATE_MINIMIZED)
{
if (gdk_surface_get_state (window) & GDK_SURFACE_STATE_MAXIMIZED)
{
set_bits |= GDK_SURFACE_STATE_WITHDRAWN;
if (IsIconic (msg->hwnd))
- set_bits |= GDK_SURFACE_STATE_ICONIFIED;
+ set_bits |= GDK_SURFACE_STATE_MINIMIZED;
else
- unset_bits |= GDK_SURFACE_STATE_ICONIFIED;
+ unset_bits |= GDK_SURFACE_STATE_MINIMIZED;
if (IsZoomed (msg->hwnd))
set_bits |= GDK_SURFACE_STATE_MAXIMIZED;
* change the iconified state in all transient related windows,
* as windows doesn't give icons for transient childrens.
*/
- if ((old_state & GDK_SURFACE_STATE_ICONIFIED) !=
- (new_state & GDK_SURFACE_STATE_ICONIFIED))
- do_show_window (window, (new_state & GDK_SURFACE_STATE_ICONIFIED));
+ if ((old_state & GDK_SURFACE_STATE_MINIMIZED) !=
+ (new_state & GDK_SURFACE_STATE_MINIMIZED))
+ do_show_window (window, (new_state & GDK_SURFACE_STATE_MINIMIZED));
/* When un-minimizing, make sure we're stacked under any
transient-type windows. */
- if (!(old_state & GDK_SURFACE_STATE_ICONIFIED) &&
- (new_state & GDK_SURFACE_STATE_ICONIFIED))
+ if (!(old_state & GDK_SURFACE_STATE_MINIMIZED) &&
+ (new_state & GDK_SURFACE_STATE_MINIMIZED))
{
ensure_stacking_on_unminimize (msg);
restack_children (window);
(bufp += sprintf (bufp, "MAPPED"), s = "|");
BIT (WITHDRAWN);
- BIT (ICONIFIED);
+ BIT (MINIMIZED);
BIT (MAXIMIZED);
BIT (STICKY);
#undef BIT
static void
show_window_internal (GdkSurface *window,
- gboolean already_mapped,
- gboolean deiconify)
+ gboolean already_mapped,
+ gboolean unminimize)
{
GdkWin32Surface *surface;
gboolean focus_on_map = FALSE;
GDK_NOTE (MISC, g_print ("show_window_internal: %p: %s%s\n",
GDK_SURFACE_HWND (window),
_gdk_win32_surface_state_to_string (window->state),
- (deiconify ? " deiconify" : "")));
+ (unminimize ? " unminimize" : "")));
- /* If asked to show (not deiconify) a withdrawn and iconified
+ /* If asked to show (not unminimize) a withdrawn and iconified
* window, do that.
*/
- if (!deiconify &&
+ if (!unminimize &&
!already_mapped &&
- (window->state & GDK_SURFACE_STATE_ICONIFIED))
+ (window->state & GDK_SURFACE_STATE_MINIMIZED))
{
GtkShowWindow (window, SW_SHOWMINNOACTIVE);
return;
}
/* If asked to just show an iconified window, do nothing. */
- if (!deiconify && (window->state & GDK_SURFACE_STATE_ICONIFIED))
+ if (!unminimize && (window->state & GDK_SURFACE_STATE_MINIMIZED))
return;
- /* If asked to deiconify an already noniconified window, do
+ /* If asked to unminimize an already noniconified window, do
* nothing. (Especially, don't cause the window to rise and
* activate. There are different calls for that.)
*/
- if (deiconify && !(window->state & GDK_SURFACE_STATE_ICONIFIED))
+ if (unminimize && !(window->state & GDK_SURFACE_STATE_MINIMIZED))
return;
/* If asked to show (but not raise) a window that is already
* visible, do nothing.
*/
- if (!deiconify && !already_mapped && IsWindowVisible (GDK_SURFACE_HWND (window)))
+ if (!unminimize && !already_mapped && IsWindowVisible (GDK_SURFACE_HWND (window)))
return;
/* Other cases */
{
GtkShowWindow (window, SW_MAXIMIZE);
}
- else if (window->state & GDK_SURFACE_STATE_ICONIFIED)
+ else if (window->state & GDK_SURFACE_STATE_MINIMIZED)
{
if (focus_on_map)
GtkShowWindow (window, SW_RESTORE);
GdkDisplay *display;
gint n_monitors;
GdkSurfaceState surface_state = gdk_surface_get_state (window);
- gboolean minimized = surface_state & GDK_SURFACE_STATE_ICONIFIED;
+ gboolean minimized = surface_state & GDK_SURFACE_STATE_MINIMIZED;
gboolean maximized = surface_state & GDK_SURFACE_STATE_MAXIMIZED;
gboolean halfsnapped;
GdkMonitor *monitor;
else if (halfsnapped)
unsnap (window, monitor);
else if (!minimized)
- gdk_surface_iconify (window);
+ gdk_surface_minimize (window);
break;
case GDK_WIN32_AEROSNAP_COMBO_LEFT:
if (maximized)
* Setting window states
*/
static void
-gdk_win32_surface_iconify (GdkSurface *window)
+gdk_win32_surface_minimize (GdkSurface *window)
{
HWND old_active_window;
if (GDK_SURFACE_DESTROYED (window))
return;
- GDK_NOTE (MISC, g_print ("gdk_surface_iconify: %p: %s\n",
+ GDK_NOTE (MISC, g_print ("gdk_surface_minimize: %p: %s\n",
GDK_SURFACE_HWND (window),
_gdk_win32_surface_state_to_string (window->state)));
else
{
gdk_synthesize_surface_state (window,
- 0,
- GDK_SURFACE_STATE_ICONIFIED);
+ 0,
+ GDK_SURFACE_STATE_MINIMIZED);
}
}
static void
-gdk_win32_surface_deiconify (GdkSurface *window)
+gdk_win32_surface_unminimize (GdkSurface *window)
{
g_return_if_fail (GDK_IS_SURFACE (window));
if (GDK_SURFACE_DESTROYED (window))
return;
- GDK_NOTE (MISC, g_print ("gdk_surface_deiconify: %p: %s\n",
+ GDK_NOTE (MISC, g_print ("gdk_surface_unminimize: %p: %s\n",
GDK_SURFACE_HWND (window),
_gdk_win32_surface_state_to_string (window->state)));
else
{
gdk_synthesize_surface_state (window,
- GDK_SURFACE_STATE_ICONIFIED,
- 0);
+ GDK_SURFACE_STATE_MINIMIZED,
+ 0);
}
}
if (window->state & GDK_SURFACE_STATE_MAXIMIZED)
GtkShowWindow (window, SW_SHOWMAXIMIZED);
- else if (window->state & GDK_SURFACE_STATE_ICONIFIED)
+ else if (window->state & GDK_SURFACE_STATE_MINIMIZED)
GtkShowWindow (window, SW_RESTORE);
else if (!IsWindowVisible (GDK_SURFACE_HWND (window)))
GtkShowWindow (window, SW_SHOWNORMAL);
impl_class->set_focus_on_map = gdk_win32_surface_set_focus_on_map;
impl_class->set_icon_list = gdk_win32_surface_set_icon_list;
impl_class->set_icon_name = gdk_win32_surface_set_icon_name;
- impl_class->iconify = gdk_win32_surface_iconify;
- impl_class->deiconify = gdk_win32_surface_deiconify;
+ impl_class->minimize = gdk_win32_surface_minimize;
+ impl_class->unminimize = gdk_win32_surface_unminimize;
impl_class->stick = gdk_win32_surface_stick;
impl_class->unstick = gdk_win32_surface_unstick;
impl_class->maximize = gdk_win32_surface_maximize;
set |= GDK_SURFACE_STATE_FOCUSED;
}
- if (old_state & GDK_SURFACE_STATE_ICONIFIED)
+ if (old_state & GDK_SURFACE_STATE_MINIMIZED)
{
if (!toplevel->have_hidden)
- unset |= GDK_SURFACE_STATE_ICONIFIED;
+ unset |= GDK_SURFACE_STATE_MINIMIZED;
}
else
{
if (toplevel->have_hidden)
- set |= GDK_SURFACE_STATE_ICONIFIED;
+ set |= GDK_SURFACE_STATE_MINIMIZED;
}
/* Update edge constraints and tiling */
/* If we are shown (not withdrawn) and get an unmap, it means we were
* iconified in the X sense. If we are withdrawn, and get an unmap, it
* means we hid the window ourselves, so we will have already flipped
- * the iconified bit off.
+ * the minimized bit off.
*/
if (GDK_SURFACE_IS_MAPPED (surface))
gdk_synthesize_surface_state (surface,
- 0,
- GDK_SURFACE_STATE_ICONIFIED);
+ 0,
+ GDK_SURFACE_STATE_MINIMIZED);
}
if (surface_impl->toplevel &&
if (surface && !is_substructure)
{
- /* Unset iconified if it was set */
- if (surface->state & GDK_SURFACE_STATE_ICONIFIED)
+ /* Unset minimized if it was set */
+ if (surface->state & GDK_SURFACE_STATE_MINIMIZED)
gdk_synthesize_surface_state (surface,
- GDK_SURFACE_STATE_ICONIFIED,
- 0);
+ GDK_SURFACE_STATE_MINIMIZED,
+ 0);
if (toplevel)
gdk_surface_thaw_updates (surface);
wm_hints.input = surface->accept_focus ? True : False;
wm_hints.initial_state = NormalState;
- if (surface->state & GDK_SURFACE_STATE_ICONIFIED)
+ if (surface->state & GDK_SURFACE_STATE_MINIMIZED)
{
wm_hints.flags |= StateHint;
wm_hints.initial_state = IconicState;
++i;
}
- if (surface->state & GDK_SURFACE_STATE_ICONIFIED)
+ if (surface->state & GDK_SURFACE_STATE_MINIMIZED)
{
atoms[i] = gdk_x11_get_xatom_by_name_for_display (display,
"_NET_WM_STATE_HIDDEN");
}
static void
-gdk_x11_surface_iconify (GdkSurface *surface)
+gdk_x11_surface_minimize (GdkSurface *surface)
{
if (GDK_SURFACE_DESTROYED (surface))
return;
else
{
/* Flip our client side flag, the real work happens on map. */
- gdk_synthesize_surface_state (surface,
- 0,
- GDK_SURFACE_STATE_ICONIFIED);
+ gdk_synthesize_surface_state (surface, 0, GDK_SURFACE_STATE_MINIMIZED);
gdk_wmspec_change_state (TRUE, surface,
g_intern_static_string ("_NET_WM_STATE_HIDDEN"),
NULL);
}
static void
-gdk_x11_surface_deiconify (GdkSurface *surface)
+gdk_x11_surface_unminimize (GdkSurface *surface)
{
if (GDK_SURFACE_DESTROYED (surface))
return;
else
{
/* Flip our client side flag, the real work happens on map. */
- gdk_synthesize_surface_state (surface,
- GDK_SURFACE_STATE_ICONIFIED,
- 0);
+ gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_MINIMIZED, 0);
gdk_wmspec_change_state (FALSE, surface,
g_intern_static_string ("_NET_WM_STATE_HIDDEN"),
NULL);
impl_class->set_focus_on_map = gdk_x11_surface_set_focus_on_map;
impl_class->set_icon_list = gdk_x11_surface_set_icon_list;
impl_class->set_icon_name = gdk_x11_surface_set_icon_name;
- impl_class->iconify = gdk_x11_surface_iconify;
- impl_class->deiconify = gdk_x11_surface_deiconify;
+ impl_class->minimize = gdk_x11_surface_minimize;
+ impl_class->unminimize = gdk_x11_surface_unminimize;
impl_class->stick = gdk_x11_surface_stick;
impl_class->unstick = gdk_x11_surface_unstick;
impl_class->maximize = gdk_x11_surface_maximize;
if (gdk_surface)
{
state = gdk_surface_get_state (gdk_surface);
- if (state & GDK_SURFACE_STATE_ICONIFIED)
+ if (state & GDK_SURFACE_STATE_MINIMIZED)
atk_state_set_add_state (state_set, ATK_STATE_ICONIFIED);
}
if (gtk_window_get_modal (window))
gtk_container_add (GTK_CONTAINER (button), image);
gtk_widget_set_can_focus (button, FALSE);
g_signal_connect_swapped (button, "clicked",
- G_CALLBACK (gtk_window_iconify), window);
+ G_CALLBACK (gtk_window_minimize), window);
accessible = gtk_widget_get_accessible (button);
if (GTK_IS_ACCESSIBLE (accessible))
guint focus_on_map : 1;
guint fullscreen_initially : 1;
guint has_user_ref_count : 1;
- guint iconify_initially : 1; /* gtk_window_iconify() called before realization */
+ guint minimize_initially : 1;
guint is_active : 1;
guint maximize_initially : 1;
guint mnemonics_visible : 1;
else if (g_str_equal (action, "lower"))
gdk_surface_lower (priv->surface);
else if (g_str_equal (action, "minimize"))
- gdk_surface_iconify (priv->surface);
+ gdk_surface_minimize (priv->surface);
else if (g_str_equal (action, "menu"))
gtk_window_do_popup (window, (GdkEventButton*) event);
else
else
gdk_surface_unstick (surface);
- if (priv->iconify_initially)
- gdk_surface_iconify (surface);
+ if (priv->minimize_initially)
+ gdk_surface_minimize (surface);
else
- gdk_surface_deiconify (surface);
+ gdk_surface_unminimize (surface);
if (priv->fullscreen_initially)
{
priv->configure_notify_received = FALSE;
state = gdk_surface_get_state (priv->surface);
- priv->iconify_initially = (state & GDK_SURFACE_STATE_ICONIFIED) != 0;
+ priv->minimize_initially = (state & GDK_SURFACE_STATE_MINIMIZED) != 0;
priv->maximize_initially = (state & GDK_SURFACE_STATE_MAXIMIZED) != 0;
priv->stick_initially = (state & GDK_SURFACE_STATE_STICKY) != 0;
priv->above_initially = (state & GDK_SURFACE_STATE_ABOVE) != 0;
state = gtk_window_get_state (window);
- if (state & GDK_SURFACE_STATE_ICONIFIED)
- gtk_window_deiconify (window);
+ if (state & GDK_SURFACE_STATE_MINIMIZED)
+ gtk_window_unminimize (window);
}
static void
GtkWindow *window = GTK_WINDOW (user_data);
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- /* Turns out, we can't iconify a maximized window */
+ /* Turns out, we can't minimize a maximized window */
if (priv->maximized)
gtk_window_unmaximize (window);
- gtk_window_iconify (window);
+ gtk_window_minimize (window);
}
static void
state = gtk_window_get_state (window);
- if (state & GDK_SURFACE_STATE_ICONIFIED)
- gtk_window_deiconify (window);
+ if (state & GDK_SURFACE_STATE_MINIMIZED)
+ gtk_window_unminimize (window);
gtk_window_maximize (window);
}
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
GtkWidget *menuitem;
GdkSurfaceState state;
- gboolean maximized, iconified;
+ gboolean maximized, minimized;
GtkWidget *box;
if (priv->popup_menu)
state = gtk_window_get_state (window);
- iconified = (state & GDK_SURFACE_STATE_ICONIFIED) == GDK_SURFACE_STATE_ICONIFIED;
- maximized = priv->maximized && !iconified;
+ minimized = (state & GDK_SURFACE_STATE_MINIMIZED) == GDK_SURFACE_STATE_MINIMIZED;
+ maximized = priv->maximized && !minimized;
priv->popup_menu = gtk_popover_menu_new (priv->title_box);
* - non-normal windows
*/
if ((gtk_widget_is_visible (GTK_WIDGET (window)) &&
- !(maximized || iconified)) ||
- (!iconified && !priv->resizable) ||
+ !(maximized || minimized)) ||
+ (!minimized && !priv->resizable) ||
priv->type_hint != GDK_SURFACE_TYPE_HINT_NORMAL)
gtk_widget_set_sensitive (menuitem, FALSE);
g_signal_connect (G_OBJECT (menuitem), "clicked",
menuitem = gtk_model_button_new ();
g_object_set (menuitem, "text", _("Move"), NULL);
- if (maximized || iconified)
+ if (maximized || minimized)
gtk_widget_set_sensitive (menuitem, FALSE);
g_signal_connect (G_OBJECT (menuitem), "clicked",
G_CALLBACK (move_window_clicked), window);
menuitem = gtk_model_button_new ();
g_object_set (menuitem, "text", _("Resize"), NULL);
- if (!priv->resizable || maximized || iconified)
+ if (!priv->resizable || maximized || minimized)
gtk_widget_set_sensitive (menuitem, FALSE);
g_signal_connect (G_OBJECT (menuitem), "clicked",
G_CALLBACK (resize_window_clicked), window);
menuitem = gtk_model_button_new ();
g_object_set (menuitem, "text", _("Minimize"), NULL);
- if (iconified ||
+ if (minimized ||
priv->type_hint != GDK_SURFACE_TYPE_HINT_NORMAL)
gtk_widget_set_sensitive (menuitem, FALSE);
g_signal_connect (G_OBJECT (menuitem), "clicked",
* button or key press event) which triggered this call
*
* Presents a window to the user. This may mean raising the window
- * in the stacking order, deiconifying it, moving it to the current
+ * in the stacking order, unminimizing it, moving it to the current
* desktop, and/or giving it the keyboard focus, possibly dependent
* on the user’s platform, window manager, and preferences.
*
}
/**
- * gtk_window_iconify:
+ * gtk_window_minimize:
* @window: a #GtkWindow
*
- * Asks to iconify (i.e. minimize) the specified @window. Note that
- * you shouldn’t assume the window is definitely iconified afterward,
- * because other entities (e.g. the user or
- * [window manager][gtk-X11-arch]) could deiconify it
- * again, or there may not be a window manager in which case
- * iconification isn’t possible, etc. But normally the window will end
- * up iconified. Just don’t write code that crashes if not.
+ * Asks to minimize the specified @window.
+ *
+ * Note that you shouldn’t assume the window is definitely minimized
+ * afterward, because the windowing system might not support this
+ * functionality; other entities (e.g. the user or the [window manager][gtk-X11-arch])
+ * could unminimize it again, or there may not be a window manager in
+ * which case minimization isn’t possible, etc.
*
* It’s permitted to call this function before showing a window,
- * in which case the window will be iconified before it ever appears
+ * in which case the window will be minimized before it ever appears
* onscreen.
*
- * You can track iconification via the #GdkSurface::state property.
+ * You can track result of this operation via the #GdkSurface:state
+ * property.
*/
void
-gtk_window_iconify (GtkWindow *window)
+gtk_window_minimize (GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
g_return_if_fail (GTK_IS_WINDOW (window));
- priv->iconify_initially = TRUE;
+ priv->minimize_initially = TRUE;
if (priv->surface)
- gdk_surface_iconify (priv->surface);
+ gdk_surface_minimize (priv->surface);
}
/**
- * gtk_window_deiconify:
+ * gtk_window_unminimize:
* @window: a #GtkWindow
*
- * Asks to deiconify (i.e. unminimize) the specified @window. Note
- * that you shouldn’t assume the window is definitely deiconified
- * afterward, because other entities (e.g. the user or
- * [window manager][gtk-X11-arch])) could iconify it
- * again before your code which assumes deiconification gets to run.
+ * Asks to unminimize the specified @window.
*
- * You can track iconification via the #GdkSurface::state property.
- **/
+ * Note that you shouldn’t assume the window is definitely unminimized
+ * afterward, because the windowing system might not support this
+ * functionality; other entities (e.g. the user or the [window manager][gtk-X11-arch])
+ * could minimize it again, or there may not be a window manager in
+ * which case minimization isn’t possible, etc.
+ *
+ * You can track result of this operation via the #GdkSurface:state
+ * property.
+ */
void
-gtk_window_deiconify (GtkWindow *window)
+gtk_window_unminimize (GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
g_return_if_fail (GTK_IS_WINDOW (window));
- priv->iconify_initially = FALSE;
+ priv->minimize_initially = FALSE;
if (priv->surface)
- gdk_surface_deiconify (priv->surface);
+ gdk_surface_unminimize (priv->surface);
}
/**
*
* It’s permitted to call this function before showing a window.
*
- * You can track iconification via the #GdkSurface::state property.
- **/
+ * You can track result of this operation via the #GdkSurface:state
+ * property.
+ */
void
gtk_window_stick (GtkWindow *window)
{
* stick it again. But normally the window will
* end up stuck. Just don’t write code that crashes if not.
*
- * You can track iconification via the #GdkSurface::state property.
- **/
+ * You can track result of this operation via the #GdkSurface:state
+ * property.
+ */
void
gtk_window_unstick (GtkWindow *window)
{
* in which case the window will be maximized when it appears onscreen
* initially.
*
- * You can track iconification via the #GdkSurface::state property
- * or by listening to notifications on the #GtkWindow:is-maximized property.
- **/
+ * You can track the result of this operation via the #GdkSurface:state
+ * property, or by listening to notifications on the #GtkWindow:is-maximized
+ * property.
+ */
void
gtk_window_maximize (GtkWindow *window)
{
* managers honor requests to unmaximize. But normally the window will
* end up unmaximized. Just don’t write code that crashes if not.
*
- * You can track iconification via the #GdkSurface::state property
- **/
+ * You can track the result of this operation via the #GdkSurface:state
+ * property, or by listening to notifications on the #GtkWindow:is-maximized
+ * property.
+ */
void
gtk_window_unmaximize (GtkWindow *window)
{
void gtk_window_present_with_time (GtkWindow *window,
guint32 timestamp);
GDK_AVAILABLE_IN_ALL
-void gtk_window_iconify (GtkWindow *window);
+void gtk_window_minimize (GtkWindow *window);
GDK_AVAILABLE_IN_ALL
-void gtk_window_deiconify (GtkWindow *window);
+void gtk_window_unminimize (GtkWindow *window);
GDK_AVAILABLE_IN_ALL
void gtk_window_stick (GtkWindow *window);
GDK_AVAILABLE_IN_ALL
msg = g_strconcat ((const char *)g_object_get_data (G_OBJECT (label), "title"), ": ",
(new_state & GDK_SURFACE_STATE_WITHDRAWN) ?
"withdrawn" : "not withdrawn", ", ",
- (new_state & GDK_SURFACE_STATE_ICONIFIED) ?
- "iconified" : "not iconified", ", ",
+ (new_state & GDK_SURFACE_STATE_MINIMIZED) ?
+ "minimized" : "not minimized", ", ",
(new_state & GDK_SURFACE_STATE_STICKY) ?
"sticky" : "not sticky", ", ",
(new_state & GDK_SURFACE_STATE_MAXIMIZED) ?
G_CALLBACK (surface_state_callback),
label);
- button = gtk_button_new_with_label ("Deiconify");
+ button = gtk_button_new_with_label ("Unminimize");
g_signal_connect_object (button,
"clicked",
- G_CALLBACK (gtk_window_deiconify),
+ G_CALLBACK (gtk_window_unminimize),
window,
G_CONNECT_SWAPPED);
gtk_container_add (GTK_CONTAINER (hbox), button);
- button = gtk_button_new_with_label ("Iconify");
+ button = gtk_button_new_with_label ("Minimize");
g_signal_connect_object (button,
"clicked",
- G_CALLBACK (gtk_window_iconify),
+ G_CALLBACK (gtk_window_minimize),
window,
G_CONNECT_SWAPPED);
gtk_container_add (GTK_CONTAINER (hbox), button);
G_CONNECT_SWAPPED);
gtk_container_add (GTK_CONTAINER (vbox), button);
- button = gtk_button_new_with_label ("Iconify");
+ button = gtk_button_new_with_label ("Minimize");
g_signal_connect_object (button,
"clicked",
- G_CALLBACK (gtk_window_iconify),
+ G_CALLBACK (gtk_window_minimize),
window,
G_CONNECT_SWAPPED);
gtk_container_add (GTK_CONTAINER (vbox), button);
G_CALLBACK (gtk_widget_destroy),
window,
G_CONNECT_SWAPPED);
- gtk_window_iconify (GTK_WINDOW (iconified));
- gtk_window_set_title (GTK_WINDOW (iconified), "Iconified initially");
+ gtk_window_minimize (GTK_WINDOW (iconified));
+ gtk_window_set_title (GTK_WINDOW (iconified), "Minimized initially");
controls = get_state_controls (iconified);
gtk_container_add (GTK_CONTAINER (iconified), controls);
window,
G_CONNECT_SWAPPED);
- gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
+ gtk_window_set_title (GTK_WINDOW (normal), "Unminimized initially");
controls = get_state_controls (normal);
gtk_container_add (GTK_CONTAINER (normal), controls);
projects / gtk4.git / commitdiff